終於到，好好玩排序法了，好ㄟ。

Kotlin 中常見的排序算法包括以下幾種：

1. 快速排序（Quick Sort）：

• 快速排序是一種高效的分治排序算法，通常用於排序大型數據集。
• 它的核心思想是選擇一個基準元素，將數據分成小於基準和大於基準的兩個子數列，然後遞迴地對這兩個子數列進行排序。
• Kotlin 標準庫中的 sorted() 和 sortedBy() 函數使用快速排序實現對集合的排序。

val numbers = listOf(5, 3, 1, 4, 2)
val sortedNumbers = numbers.sorted()

2. 合併排序（Merge Sort）：

• 合併排序是一種穩定且高效的分治排序算法，它遞迴地將數據分成較小的子數列，然後將這些子數列合併成有序的數列。
• 優點是它對於大型數據集的性能穩定，但需要額外的存儲空間。
• Kotlin 標準庫中的 sorted() 函數可以使用合併排序或快速排序，具體取決於數據集的大小。

val numbers = listOf(5, 3, 1, 4, 2)
val sortedNumbers = numbers.sorted()

3. 插入排序（Insertion Sort）：

• 插入排序是一種簡單的排序算法，它遍歷數據，將每個元素插入到已排序的部分中，直到整個數據集排序完成。
• 對於小型數據集或部分有序的數據集，插入排序通常效率較高。

val numbers = mutableListOf(5, 3, 1, 4, 2)
for (i in 1 until numbers.size) {
    val current = numbers[i]
    var j = i - 1
    while (j >= 0 && numbers[j] > current) {
        numbers[j + 1] = numbers[j]
        j--
    }
    numbers[j + 1] = current
}

4. 選擇排序（Selection Sort）：

• 選擇排序是一種簡單的排序算法，它每次選擇最小（或最大）的元素並將其放到正確的位置。
• 儘管它在效率上不如快速排序或合併排序，但對於小型數據集，它可以是一種合理的選擇。

val numbers = mutableListOf(5, 3, 1, 4, 2)
for (i in 0 until numbers.size - 1) {
    var minIndex = i
    for (j in i + 1 until numbers.size) {
        if (numbers[j] < numbers[minIndex]) {
            minIndex = j
        }
    }
    val temp = numbers[i]
    numbers[i] = numbers[minIndex]
    numbers[minIndex] = temp
}

5. 泡沫排序（Bubble Sort）：

泡沫排序是一種簡單易實現的排序算法，但對於大型數據集來說效率較低，因為其時間複雜度為 O(n^2)，其中 n 是數據集的大小。因此，在實際應用中，對於大型數據集，通常選擇更高效的排序算法，如快速排序或合併排序。

fun bubbleSort(arr: IntArray) {
    val n = arr.size
    var swapped: Boolean
    do {
        swapped = false
        for (i in 0 until n - 1) {
            if (arr[i] > arr[i + 1]) {
                // 交換元素
                val temp = arr[i]
                arr[i] = arr[i + 1]
                arr[i + 1] = temp
                swapped = true
            }
        }
    } while (swapped)
}

fun main() {
    val numbers = intArrayOf(5, 3, 1, 4, 2)
    bubbleSort(numbers)
    println("排序後的數組：${numbers.joinToString()}")
}